home *** CD-ROM | disk | FTP | other *** search
/ Champak 33 / Volume 33 - JOGO DISK .iso / Games / santas_gift_jump.swf / scripts / DefineSprite_107_spiridus / frame_65 / DoAction.as
Text File  |  2007-01-16  |  62KB  |  1,108 lines

  1. var ┬º\x01┬º = 258;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") != 258)
  6.    {
  7.       if(eval("\x01") == 284)
  8.       {
  9.          set("\x01",eval("\x01") + 66);
  10.          break;
  11.       }
  12.       if(eval("\x01") != 673)
  13.       {
  14.          if(eval("\x01") == 410)
  15.          {
  16.             set("\x01",eval("\x01") - 9);
  17.             break;
  18.          }
  19.          if(eval("\x01") == 180)
  20.          {
  21.             set("\x01",eval("\x01") + 407);
  22.             if(┬º┬ºpop())
  23.             {
  24.                set("\x01",eval("\x01") - 441);
  25.             }
  26.             continue;
  27.             continue;
  28.          }
  29.          if(eval("\x01") == 148)
  30.          {
  31.             set("\x01",eval("\x01") + 136);
  32.             if(┬º┬ºpop())
  33.             {
  34.                set("\x01",eval("\x01") + 66);
  35.             }
  36.             continue;
  37.          }
  38.          if(eval("\x01") == 146)
  39.          {
  40.             set("\x01",eval("\x01") + 2);
  41.             ┬º┬ºpush(true);
  42.             continue;
  43.          }
  44.          if(eval("\x01") != 822)
  45.          {
  46.             if(eval("\x01") == 869)
  47.             {
  48.                set("\x01",eval("\x01") - 47);
  49.                prevFrame();
  50.                break;
  51.             }
  52.             if(eval("\x01") != 411)
  53.             {
  54.                if(eval("\x01") != 201)
  55.                {
  56.                   if(eval("\x01") == 228)
  57.                   {
  58.                      set("\x01",eval("\x01") + 445);
  59.                      with(┬º┬ºpop())
  60.                      {
  61.                      }
  62.                   }
  63.                   else
  64.                   {
  65.                      if(eval("\x01") == 813)
  66.                      {
  67.                         set("\x01",eval("\x01") + 136);
  68.                         if(┬º┬ºpop())
  69.                         {
  70.                            set("\x01",eval("\x01") - 748);
  71.                         }
  72.                         continue;
  73.                      }
  74.                      if(eval("\x01") == 618)
  75.                      {
  76.                         set("\x01",eval("\x01") - 208);
  77.                         if(┬º┬ºpop())
  78.                         {
  79.                            set("\x01",eval("\x01") - 9);
  80.                         }
  81.                         continue;
  82.                      }
  83.                      if(eval("\x01") == 709)
  84.                      {
  85.                         set("\x01",eval("\x01") - 481);
  86.                         if(┬º┬ºpop())
  87.                         {
  88.                            set("\x01",eval("\x01") + 445);
  89.                         }
  90.                         continue;
  91.                      }
  92.                      if(eval("\x01") == 401)
  93.                      {
  94.                         set("\x01",eval("\x01") - 186);
  95.                         ┬º┬ºpush(true);
  96.                         continue;
  97.                      }
  98.                      if(eval("\x01") == 350)
  99.                      {
  100.                         set("\x01",eval("\x01") + 359);
  101.                         ┬º┬ºpush(true);
  102.                         continue;
  103.                      }
  104.                      if(eval("\x01") == 215)
  105.                      {
  106.                         set("\x01",eval("\x01") + 46);
  107.                         if(┬º┬ºpop())
  108.                         {
  109.                            set("\x01",eval("\x01") - 187);
  110.                         }
  111.                         continue;
  112.                      }
  113.                      if(eval("\x01") == 949)
  114.                      {
  115.                         set("\x01",eval("\x01") - 748);
  116.                         break;
  117.                      }
  118.                      if(eval("\x01") == 587)
  119.                      {
  120.                         set("\x01",eval("\x01") - 441);
  121.                         loop3:
  122.                         while(true)
  123.                         {
  124.                            set(┬º┬ºpop(),eval(┬º┬ºpop()) + 25);
  125.                            ┬º┬ºpush(true);
  126.                            while(true)
  127.                            {
  128.                               if(eval("\x01") == 977)
  129.                               {
  130.                                  set("\x01",eval("\x01") - 269);
  131.                                  ┬º┬ºpush(true);
  132.                                  continue;
  133.                               }
  134.                               if(eval("\x01") == 464)
  135.                               {
  136.                                  set("\x01",eval("\x01") + 328);
  137.                                  cadou._y = igrec;
  138.                                  stop();
  139.                                  break loop0;
  140.                               }
  141.                               if(eval("\x01") == 133)
  142.                               {
  143.                                  set("\x01",eval("\x01") + 857);
  144.                                  break loop0;
  145.                               }
  146.                               if(eval("\x01") == 277)
  147.                               {
  148.                                  set("\x01",eval("\x01") - 64);
  149.                                  ┬º┬ºpush(┬º┬ºpop() - new ┬º\┬º\┬ºpop()┬º());
  150.                                  break loop0;
  151.                               }
  152.                               if(eval("\x01") != 988)
  153.                               {
  154.                                  if(eval("\x01") == 500)
  155.                                  {
  156.                                     set("\x01",eval("\x01") - 58);
  157.                                     ┬º┬ºpush(true);
  158.                                  }
  159.                                  else if(eval("\x01") == 25)
  160.                                  {
  161.                                     set("\x01",eval("\x01") + 108);
  162.                                     if(┬º┬ºpop())
  163.                                     {
  164.                                        set("\x01",eval("\x01") + 857);
  165.                                     }
  166.                                  }
  167.                                  else if(eval("\x01") == 708)
  168.                                  {
  169.                                     set("\x01",eval("\x01") - 4);
  170.                                     if(┬º┬ºpop())
  171.                                     {
  172.                                        set("\x01",eval("\x01") - 204);
  173.                                     }
  174.                                  }
  175.                                  else if(eval("\x01") == 180)
  176.                                  {
  177.                                     set("\x01",eval("\x01") - 155);
  178.                                     ┬º┬ºpush(true);
  179.                                  }
  180.                                  else
  181.                                  {
  182.                                     if(eval("\x01") == 545)
  183.                                     {
  184.                                        break loop3;
  185.                                     }
  186.                                     if(eval("\x01") == 213)
  187.                                     {
  188.                                        break;
  189.                                     }
  190.                                     if(eval("\x01") == 238)
  191.                                     {
  192.                                        set("\x01",eval("\x01") + 750);
  193.                                        if(┬º┬ºpop())
  194.                                        {
  195.                                           set("\x01",eval("\x01") - 524);
  196.                                        }
  197.                                     }
  198.                                     else if(eval("\x01") == 732)
  199.                                     {
  200.                                        set("\x01",eval("\x01") - 455);
  201.                                        if(┬º┬ºpop())
  202.                                        {
  203.                                           set("\x01",eval("\x01") - 64);
  204.                                        }
  205.                                     }
  206.                                     else if(eval("\x01") == 990)
  207.                                     {
  208.                                        set("\x01",eval("\x01") - 258);
  209.                                        ┬º┬ºpush(true);
  210.                                     }
  211.                                     else
  212.                                     {
  213.                                        if(eval("\x01") == 792)
  214.                                        {
  215.                                           set("\x01",eval("\x01") - 792);
  216.                                           break loop0;
  217.                                        }
  218.                                        if(eval("\x01") != 442)
  219.                                        {
  220.                                           if(eval("\x01") == 704)
  221.                                           {
  222.                                              set("\x01",eval("\x01") - 204);
  223.                                              break loop0;
  224.                                           }
  225.                                           break loop0;
  226.                                        }
  227.                                        set("\x01",eval("\x01") + 103);
  228.                                        if(┬º┬ºpop())
  229.                                        {
  230.                                           set("\x01",eval("\x01") - 365);
  231.                                        }
  232.                                     }
  233.                                  }
  234.                                  continue;
  235.                               }
  236.                               set("\x01",eval("\x01") - 524);
  237.                               gotoAndStop("");
  238.                               loop5:
  239.                               while(true)
  240.                               {
  241.                                  if(!┬º┬ºpop())
  242.                                  {
  243.                                     set("\x01",eval("\x01") - 714);
  244.                                     if(┬º┬ºpop())
  245.                                     {
  246.                                        set("\x01",eval("\x01") - 43);
  247.                                     }
  248.                                  }
  249.                                  else if(eval("\x01") == 343)
  250.                                  {
  251.                                     set("\x01",eval("\x01") + 270);
  252.                                     ┬º┬ºpush(true);
  253.                                  }
  254.                                  else if(eval("\x01") == 950)
  255.                                  {
  256.                                     set("\x01",eval("\x01") - 881);
  257.                                     if(┬º┬ºpop())
  258.                                     {
  259.                                        set("\x01",eval("\x01") + 193);
  260.                                     }
  261.                                  }
  262.                                  else if(eval("\x01") == 253)
  263.                                  {
  264.                                     set("\x01",eval("\x01") + 227);
  265.                                     ┬º┬ºpush(true);
  266.                                  }
  267.                                  else
  268.                                  {
  269.                                     if(eval("\x01") == 719)
  270.                                     {
  271.                                        set("\x01",eval("\x01") + 94);
  272.                                        break loop0;
  273.                                     }
  274.                                     if(eval("\x01") == 813)
  275.                                     {
  276.                                        set("\x01",eval("\x01") - 356);
  277.                                        ┬º┬ºpush(true);
  278.                                     }
  279.                                     else
  280.                                     {
  281.                                        if(eval("\x01") == 218)
  282.                                        {
  283.                                           set("\x01",eval("\x01") + 35);
  284.                                           loop7:
  285.                                           while(true)
  286.                                           {
  287.                                              if(eval("\x01") == 406)
  288.                                              {
  289.                                                 set("\x01",eval("\x01") - 40);
  290.                                                 break loop0;
  291.                                              }
  292.                                              if(eval("\x01") == 292)
  293.                                              {
  294.                                                 set("\x01",eval("\x01") + 428);
  295.                                                 break loop0;
  296.                                              }
  297.                                              if(eval("\x01") == 753)
  298.                                              {
  299.                                                 set("\x01",eval("\x01") + 147);
  300.                                                 if(┬º┬ºpop())
  301.                                                 {
  302.                                                    set("\x01",eval("\x01") - 334);
  303.                                                 }
  304.                                              }
  305.                                              else if(eval("\x01") == 60)
  306.                                              {
  307.                                                 set("\x01",eval("\x01") + 232);
  308.                                                 if(┬º┬ºpop())
  309.                                                 {
  310.                                                    set("\x01",eval("\x01") + 428);
  311.                                                 }
  312.                                              }
  313.                                              else if(eval("\x01") == 508)
  314.                                              {
  315.                                                 set("\x01",eval("\x01") - 138);
  316.                                                 if(┬º┬ºpop())
  317.                                                 {
  318.                                                    set("\x01",eval("\x01") - 322);
  319.                                                 }
  320.                                              }
  321.                                              else if(eval("\x01") == 181)
  322.                                              {
  323.                                                 set("\x01",eval("\x01") + 605);
  324.                                                 ┬º┬ºpush(true);
  325.                                              }
  326.                                              else
  327.                                              {
  328.                                                 if(eval("\x01") == 370)
  329.                                                 {
  330.                                                    set("\x01",eval("\x01") - 322);
  331.                                                    stop();
  332.                                                    ┬º┬ºpush(┬º┬ºpop() | ┬º┬ºpop());
  333.                                                    break loop0;
  334.                                                 }
  335.                                                 if(eval("\x01") == 48)
  336.                                                 {
  337.                                                    set("\x01",eval("\x01") + 615);
  338.                                                    ┬º┬ºpush(true);
  339.                                                 }
  340.                                                 else if(eval("\x01") == 619)
  341.                                                 {
  342.                                                    set("\x01",eval("\x01") + 268);
  343.                                                    ┬º┬ºpush(true);
  344.                                                 }
  345.                                                 else if(eval("\x01") == 503)
  346.                                                 {
  347.                                                    set("\x01",eval("\x01") + 307);
  348.                                                    if(┬º┬ºpop())
  349.                                                    {
  350.                                                       set("\x01",eval("\x01") - 443);
  351.                                                    }
  352.                                                 }
  353.                                                 else if(eval("\x01") == 367)
  354.                                                 {
  355.                                                    set("\x01",eval("\x01") - 307);
  356.                                                    ┬º┬ºpush(true);
  357.                                                 }
  358.                                                 else
  359.                                                 {
  360.                                                    if(eval("\x01") == 656)
  361.                                                    {
  362.                                                       break;
  363.                                                    }
  364.                                                    if(eval("\x01") == 220)
  365.                                                    {
  366.                                                       set("\x01",eval("\x01") + 394);
  367.                                                       break loop0;
  368.                                                    }
  369.                                                    if(eval("\x01") == 882)
  370.                                                    {
  371.                                                       set("\x01",eval("\x01") + 79);
  372.                                                       ┬º┬ºpush(true);
  373.                                                    }
  374.                                                    else
  375.                                                    {
  376.                                                       if(eval("\x01") != 961)
  377.                                                       {
  378.                                                          if(eval("\x01") == 280)
  379.                                                          {
  380.                                                             set("\x01",eval("\x01") - 280);
  381.                                                             break loop0;
  382.                                                          }
  383.                                                          break loop0;
  384.                                                       }
  385.                                                       set("\x01",eval("\x01") - 741);
  386.                                                       if(┬º┬ºpop())
  387.                                                       {
  388.                                                          set("\x01",eval("\x01") + 394);
  389.                                                       }
  390.                                                    }
  391.                                                 }
  392.                                              }
  393.                                              while(true)
  394.                                              {
  395.                                                 if(eval("\x01") == 587)
  396.                                                 {
  397.                                                    set("\x01",eval("\x01") + 166);
  398.                                                    ┬º┬ºpush(true);
  399.                                                    continue;
  400.                                                 }
  401.                                                 if(eval("\x01") == 43)
  402.                                                 {
  403.                                                    set("\x01",eval("\x01") + 576);
  404.                                                    ┬º┬ºpush(String(┬º┬ºpop()));
  405.                                                    break loop0;
  406.                                                 }
  407.                                                 if(eval("\x01") == 900)
  408.                                                 {
  409.                                                    set("\x01",eval("\x01") - 334);
  410.                                                    break loop0;
  411.                                                 }
  412.                                                 if(eval("\x01") == 887)
  413.                                                 {
  414.                                                    set("\x01",eval("\x01") - 481);
  415.                                                    if(┬º┬ºpop())
  416.                                                    {
  417.                                                       set("\x01",eval("\x01") - 40);
  418.                                                    }
  419.                                                    continue;
  420.                                                 }
  421.                                                 if(eval("\x01") == 566)
  422.                                                 {
  423.                                                    set("\x01",eval("\x01") - 58);
  424.                                                    ┬º┬ºpush(true);
  425.                                                    continue;
  426.                                                 }
  427.                                                 if(eval("\x01") == 366)
  428.                                                 {
  429.                                                    set("\x01",eval("\x01") + 137);
  430.                                                    ┬º┬ºpush(true);
  431.                                                    continue;
  432.                                                 }
  433.                                                 if(eval("\x01") == 810)
  434.                                                 {
  435.                                                    set("\x01",eval("\x01") - 443);
  436.                                                    break loop0;
  437.                                                 }
  438.                                                 if(eval("\x01") == 906)
  439.                                                 {
  440.                                                    set("\x01",eval("\x01") - 725);
  441.                                                    break loop0;
  442.                                                 }
  443.                                                 if(eval("\x01") == 663)
  444.                                                 {
  445.                                                    set("\x01",eval("\x01") - 620);
  446.                                                    if(┬º┬ºpop())
  447.                                                    {
  448.                                                       set("\x01",eval("\x01") + 576);
  449.                                                    }
  450.                                                    continue;
  451.                                                 }
  452.                                                 if(eval("\x01") == 601)
  453.                                                 {
  454.                                                    set("\x01",eval("\x01") + 305);
  455.                                                    if(┬º┬ºpop())
  456.                                                    {
  457.                                                       set("\x01",eval("\x01") - 725);
  458.                                                    }
  459.                                                    continue;
  460.                                                 }
  461.                                                 if(eval("\x01") == 720)
  462.                                                 {
  463.                                                    set("\x01",eval("\x01") - 119);
  464.                                                    ┬º┬ºpush(true);
  465.                                                    continue;
  466.                                                 }
  467.                                                 if(eval("\x01") == 786)
  468.                                                 {
  469.                                                    set("\x01",eval("\x01") - 130);
  470.                                                    if(┬º┬ºpop())
  471.                                                    {
  472.                                                       set("\x01",eval("\x01") + 226);
  473.                                                    }
  474.                                                    continue;
  475.                                                 }
  476.                                                 continue loop7;
  477.                                              }
  478.                                           }
  479.                                           set("\x01",eval("\x01") + 226);
  480.                                        }
  481.                                        if(eval("\x01") == 368)
  482.                                        {
  483.                                           set("\x01",eval("\x01") + 582);
  484.                                           ┬º┬ºpush(true);
  485.                                        }
  486.                                        else if(eval("\x01") == 480)
  487.                                        {
  488.                                           set("\x01",eval("\x01") + 216);
  489.                                           if(┬º┬ºpop())
  490.                                           {
  491.                                              set("\x01",eval("\x01") - 199);
  492.                                           }
  493.                                        }
  494.                                        else if(eval("\x01") == 767)
  495.                                        {
  496.                                           set("\x01",eval("\x01") + 17);
  497.                                           ┬º┬ºpush(true);
  498.                                        }
  499.                                        else if(eval("\x01") == 696)
  500.                                        {
  501.                                           set("\x01",eval("\x01") - 199);
  502.                                           loop11:
  503.                                           while(true)
  504.                                           {
  505.                                              set(┬º┬ºpop(),eval(┬º┬ºpop()) + 335);
  506.                                              loop12:
  507.                                              while(true)
  508.                                              {
  509.                                                 while(true)
  510.                                                 {
  511.                                                    if(eval("\x01") != 716)
  512.                                                    {
  513.                                                       if(eval("\x01") != 411)
  514.                                                       {
  515.                                                          if(eval("\x01") == 76)
  516.                                                          {
  517.                                                             set("\x01",eval("\x01") + 335);
  518.                                                             break loop0;
  519.                                                          }
  520.                                                          if(eval("\x01") == 549)
  521.                                                          {
  522.                                                             break loop12;
  523.                                                          }
  524.                                                          if(eval("\x01") == 94)
  525.                                                          {
  526.                                                             set("\x01",eval("\x01") + 455);
  527.                                                             if(┬º┬ºpop())
  528.                                                             {
  529.                                                                set("\x01",eval("\x01") - 401);
  530.                                                             }
  531.                                                             continue;
  532.                                                             if(┬º┬ºpop())
  533.                                                             {
  534.                                                                set("\x01",eval("\x01") - 41);
  535.                                                             }
  536.                                                          }
  537.                                                          if(eval("\x01") != 148)
  538.                                                          {
  539.                                                             if(eval("\x01") == 512)
  540.                                                             {
  541.                                                                break;
  542.                                                             }
  543.                                                             if(eval("\x01") == 303)
  544.                                                             {
  545.                                                                set("\x01",eval("\x01") - 41);
  546.                                                                break loop0;
  547.                                                             }
  548.                                                             if(eval("\x01") != 860)
  549.                                                             {
  550.                                                                if(eval("\x01") == 262)
  551.                                                                {
  552.                                                                   set("\x01",eval("\x01") + 673);
  553.                                                                   frame = random(3) + 1;
  554.                                                                   gotoAndStop(frame);
  555.                                                                   break loop0;
  556.                                                                }
  557.                                                                if(eval("\x01") == 935)
  558.                                                                {
  559.                                                                   set("\x01",eval("\x01") - 935);
  560.                                                                   break loop0;
  561.                                                                }
  562.                                                             }
  563.                                                             set("\x01",eval("\x01") - 557);
  564.                                                          }
  565.                                                          set("\x01",eval("\x01") + 364);
  566.                                                       }
  567.                                                       set("\x01",eval("\x01") + 449);
  568.                                                       ┬º┬ºpush(true);
  569.                                                       continue;
  570.                                                       ┬º┬ºpush(true);
  571.                                                    }
  572.                                                    set("\x01",eval("\x01") - 622);
  573.                                                    ┬º┬ºpush(true);
  574.                                                 }
  575.                                                 set("\x01",eval("\x01") - 436);
  576.                                                 if(!┬º┬ºpop())
  577.                                                 {
  578.                                                    continue;
  579.                                                 }
  580.                                                 continue loop11;
  581.                                              }
  582.                                              set("\x01",eval("\x01") - 401);
  583.                                              var ┬º┬ºpop() = ┬º┬ºpop();
  584.                                              ifFrameLoaded(6280)
  585.                                              {
  586.                                              }
  587.                                           }
  588.                                        }
  589.                                        else if(eval("\x01") == 151)
  590.                                        {
  591.                                           set("\x01",eval("\x01") + 433);
  592.                                           ┬º┬ºpush(true);
  593.                                        }
  594.                                        else if(eval("\x01") == 152)
  595.                                        {
  596.                                           set("\x01",eval("\x01") + 63);
  597.                                           if(┬º┬ºpop())
  598.                                           {
  599.                                              set("\x01",eval("\x01") + 552);
  600.                                           }
  601.                                        }
  602.                                        else
  603.                                        {
  604.                                           if(eval("\x01") == 578)
  605.                                           {
  606.                                              set("\x01",eval("\x01") - 210);
  607.                                              break loop0;
  608.                                           }
  609.                                           if(eval("\x01") == 497)
  610.                                           {
  611.                                              set("\x01",eval("\x01") + 411);
  612.                                              ┬º┬ºpush(true);
  613.                                           }
  614.                                           else
  615.                                           {
  616.                                              if(eval("\x01") == 356)
  617.                                              {
  618.                                                 set("\x01",eval("\x01") - 13);
  619.                                                 ┬º┬ºpush(┬º┬ºpop() - 1);
  620.                                                 break loop0;
  621.                                              }
  622.                                              if(eval("\x01") == 215)
  623.                                              {
  624.                                                 set("\x01",eval("\x01") + 552);
  625.                                                 break loop0;
  626.                                              }
  627.                                              if(eval("\x01") == 194)
  628.                                              {
  629.                                                 set("\x01",eval("\x01") - 43);
  630.                                                 while(true)
  631.                                                 {
  632.                                                    if(┬º┬ºpop() == ┬º┬ºpop())
  633.                                                    {
  634.                                                       set("\x01",eval("\x01") - 919);
  635.                                                       break loop0;
  636.                                                    }
  637.                                                    if(eval("\x01") == 918)
  638.                                                    {
  639.                                                       set("\x01",eval("\x01") - 85);
  640.                                                       ┬º┬ºpush(true);
  641.                                                    }
  642.                                                    else if(eval("\x01") == 203)
  643.                                                    {
  644.                                                       set("\x01",eval("\x01") - 180);
  645.                                                       if(┬º┬ºpop())
  646.                                                       {
  647.                                                          set("\x01",eval("\x01") - 8);
  648.                                                       }
  649.                                                    }
  650.                                                    else
  651.                                                    {
  652.                                                       if(eval("\x01") == 890)
  653.                                                       {
  654.                                                          set("\x01",eval("\x01") + 28);
  655.                                                          break loop0;
  656.                                                       }
  657.                                                       if(eval("\x01") == 745)
  658.                                                       {
  659.                                                          set("\x01",eval("\x01") - 91);
  660.                                                          break loop0;
  661.                                                       }
  662.                                                       if(eval("\x01") == 669)
  663.                                                       {
  664.                                                          set("\x01",eval("\x01") + 76);
  665.                                                          if(┬º┬ºpop())
  666.                                                          {
  667.                                                             set("\x01",eval("\x01") - 91);
  668.                                                          }
  669.                                                       }
  670.                                                       else if(eval("\x01") == 654)
  671.                                                       {
  672.                                                          set("\x01",eval("\x01") - 451);
  673.                                                          ┬º┬ºpush(true);
  674.                                                       }
  675.                                                       else if(eval("\x01") == 843)
  676.                                                       {
  677.                                                          set("\x01",eval("\x01") + 47);
  678.                                                          if(┬º┬ºpop())
  679.                                                          {
  680.                                                             set("\x01",eval("\x01") + 28);
  681.                                                          }
  682.                                                       }
  683.                                                       else if(eval("\x01") == 833)
  684.                                                       {
  685.                                                          set("\x01",eval("\x01") - 274);
  686.                                                          if(┬º┬ºpop())
  687.                                                          {
  688.                                                             set("\x01",eval("\x01") + 17);
  689.                                                          }
  690.                                                       }
  691.                                                       else
  692.                                                       {
  693.                                                          if(eval("\x01") == 23)
  694.                                                          {
  695.                                                             set("\x01",eval("\x01") - 8);
  696.                                                             toggleHighQuality();
  697.                                                             play();
  698.                                                             ┬º┬ºpop()[┬º┬ºpop()] = eval(┬º┬ºpop() / ┬º┬ºpop());
  699.                                                             this[┬º┬ºconstant(14)] = eval(┬º┬ºconstant(9));
  700.                                                             break loop0;
  701.                                                          }
  702.                                                          if(eval("\x01") == 15)
  703.                                                          {
  704.                                                             set("\x01",eval("\x01") + 227);
  705.                                                             ┬º┬ºpush(true);
  706.                                                          }
  707.                                                          else
  708.                                                          {
  709.                                                             if(eval("\x01") == 319)
  710.                                                             {
  711.                                                                set("\x01",eval("\x01") + 99);
  712.                                                                set("\x01",eval("\x01") + 316);
  713.                                                                ┬º┬ºpush(┬º┬ºpop() ^ ┬º┬ºpop());
  714.                                                                if(_parent._parent._parent.pauza == false)
  715.                                                                {
  716.                                                                   x++;
  717.                                                                   if(x >= limita)
  718.                                                                   {
  719.                                                                      if(_parent._currentframe <= 24)
  720.                                                                      {
  721.                                                                         _parent.gotoAndPlay("retragere4");
  722.                                                                      }
  723.                                                                      else
  724.                                                                      {
  725.                                                                         _parent.gotoAndPlay("retragere3");
  726.                                                                      }
  727.                                                                   }
  728.                                                                   else
  729.                                                                   {
  730.                                                                      gotoAndStop("lup");
  731.                                                                      play();
  732.                                                                   }
  733.                                                                }
  734.                                                                else
  735.                                                                {
  736.                                                                   gotoAndPlay(24);
  737.                                                                }
  738.                                                                break loop0;
  739.                                                             }
  740.                                                             if(eval("\x01") == 242)
  741.                                                             {
  742.                                                                set("\x01",eval("\x01") - 137);
  743.                                                                if(┬º┬ºpop())
  744.                                                                {
  745.                                                                   set("\x01",eval("\x01") + 53);
  746.                                                                }
  747.                                                             }
  748.                                                             else if(eval("\x01") == 947)
  749.                                                             {
  750.                                                                set("\x01",eval("\x01") - 628);
  751.                                                                if(┬º┬ºpop())
  752.                                                                {
  753.                                                                   set("\x01",eval("\x01") + 99);
  754.                                                                }
  755.                                                             }
  756.                                                             else
  757.                                                             {
  758.                                                                if(eval("\x01") != 576)
  759.                                                                {
  760.                                                                   if(eval("\x01") == 559)
  761.                                                                   {
  762.                                                                      set("\x01",eval("\x01") + 17);
  763.                                                                      set(┬º┬ºpop(),new ┬º\┬º\┬ºpop()┬º());
  764.                                                                      eval(┬º┬ºconstant(10)).this(┬º┬ºconstant(10));
  765.                                                                      set(┬º┬ºconstant(11),new _name());
  766.                                                                      eval(┬º┬ºconstant(11)).this(┬º┬ºconstant(11));
  767.                                                                      set(┬º┬ºconstant(12),new _name());
  768.                                                                      eval(┬º┬ºconstant(12)).this(┬º┬ºconstant(12));
  769.                                                                      set(┬º┬ºconstant(13),new _name());
  770.                                                                      eval(┬º┬ºconstant(13)).this(┬º┬ºconstant(13));
  771.                                                                      set(┬º┬ºconstant(14),new _name());
  772.                                                                      eval(┬º┬ºconstant(14)).this(┬º┬ºconstant(14));
  773.                                                                      set(┬º┬ºconstant(15),new _name());
  774.                                                                      eval(┬º┬ºconstant(15)).this(┬º┬ºconstant(15));
  775.                                                                      set(┬º┬ºconstant(16),new _name());
  776.                                                                      eval(┬º┬ºconstant(16)).this(┬º┬ºconstant(16));
  777.                                                                      set(┬º┬ºconstant(17),new _name());
  778.                                                                      eval(┬º┬ºconstant(17)).this(┬º┬ºconstant(17));
  779.                                                                      break loop0;
  780.                                                                   }
  781.                                                                   break loop0;
  782.                                                                }
  783.                                                                set("\x01",eval("\x01") + 371);
  784.                                                                ┬º┬ºpush(true);
  785.                                                             }
  786.                                                          }
  787.                                                       }
  788.                                                    }
  789.                                                    while(true)
  790.                                                    {
  791.                                                       if(eval("\x01") == 85)
  792.                                                       {
  793.                                                          set("\x01",eval("\x01") + 758);
  794.                                                          ┬º┬ºpush(true);
  795.                                                       }
  796.                                                       else
  797.                                                       {
  798.                                                          if(eval("\x01") != 418)
  799.                                                          {
  800.                                                             break;
  801.                                                          }
  802.                                                          set("\x01",eval("\x01") + 251);
  803.                                                          ┬º┬ºpush(true);
  804.                                                       }
  805.                                                    }
  806.                                                    if(eval("\x01") == 158)
  807.                                                    {
  808.                                                       set("\x01",eval("\x01") + 761);
  809.                                                       root = _parent._parent._parent._parent;
  810.                                                       if(_parent._parent._currentframe == 1 && root.mosStat != "mort")
  811.                                                       {
  812.                                                          _parent._parent._parent._parent.contor = _parent._parent._parent._parent.contor + 1;
  813.                                                          _parent._parent._parent.attachMovie("urmaCadou","urmaCadou" + _parent._parent._parent._parent.contor,_parent._parent._parent._parent.contor);
  814.                                                          _parent._parent._parent["urmaCadou" + _parent._parent._parent._parent.contor]._x = _parent._parent._x + (random(30) + 1);
  815.                                                          _parent._parent._parent["urmaCadou" + _parent._parent._parent._parent.contor]._y = _parent._parent.cadou._y + 285;
  816.                                                       }
  817.                                                       break loop0;
  818.                                                    }
  819.                                                    if(eval("\x01") == 105)
  820.                                                    {
  821.                                                       set("\x01",eval("\x01") + 53);
  822.                                                       ┬º┬ºpush(delete ┬º┬ºpop()[typeof ┬º┬ºpop()]);
  823.                                                       break loop0;
  824.                                                    }
  825.                                                 }
  826.                                              }
  827.                                              else if(eval("\x01") == 584)
  828.                                              {
  829.                                                 set("\x01",eval("\x01") - 228);
  830.                                                 if(┬º┬ºpop())
  831.                                                 {
  832.                                                    set("\x01",eval("\x01") - 13);
  833.                                                 }
  834.                                              }
  835.                                              else
  836.                                              {
  837.                                                 if(eval("\x01") != 613)
  838.                                                 {
  839.                                                    if(eval("\x01") == 456)
  840.                                                    {
  841.                                                       set("\x01",eval("\x01") - 72);
  842.                                                       break loop0;
  843.                                                    }
  844.                                                    if(eval("\x01") == 384)
  845.                                                    {
  846.                                                       set("\x01",eval("\x01") - 261);
  847.                                                       _parent.gotoAndStop("remove");
  848.                                                       break loop0;
  849.                                                    }
  850.                                                    if(eval("\x01") == 123)
  851.                                                    {
  852.                                                       set("\x01",eval("\x01") - 123);
  853.                                                       break loop0;
  854.                                                    }
  855.                                                    break loop0;
  856.                                                 }
  857.                                                 set("\x01",eval("\x01") - 157);
  858.                                                 if(┬º┬ºpop())
  859.                                                 {
  860.                                                    set("\x01",eval("\x01") - 72);
  861.                                                 }
  862.                                              }
  863.                                           }
  864.                                        }
  865.                                     }
  866.                                  }
  867.                                  while(true)
  868.                                  {
  869.                                     if(eval("\x01") == 555)
  870.                                     {
  871.                                        set("\x01",eval("\x01") + 316);
  872.                                        ┬º┬ºpush(true);
  873.                                        continue;
  874.                                     }
  875.                                     if(eval("\x01") == 69)
  876.                                     {
  877.                                        break;
  878.                                     }
  879.                                     if(eval("\x01") == 871)
  880.                                     {
  881.                                        set("\x01",eval("\x01") - 293);
  882.                                        if(┬º┬ºpop())
  883.                                        {
  884.                                           set("\x01",eval("\x01") - 210);
  885.                                        }
  886.                                        continue;
  887.                                     }
  888.                                     if(eval("\x01") == 784)
  889.                                     {
  890.                                        set("\x01",eval("\x01") - 65);
  891.                                        if(┬º┬ºpop())
  892.                                        {
  893.                                           set("\x01",eval("\x01") + 94);
  894.                                        }
  895.                                        continue;
  896.                                     }
  897.                                     if(eval("\x01") == 457)
  898.                                     {
  899.                                        set("\x01",eval("\x01") - 239);
  900.                                        if(┬º┬ºpop())
  901.                                        {
  902.                                           set("\x01",eval("\x01") + 35);
  903.                                        }
  904.                                        continue;
  905.                                     }
  906.                                     if(eval("\x01") == 262)
  907.                                     {
  908.                                        set("\x01",eval("\x01") - 110);
  909.                                        ┬º┬ºpush(true);
  910.                                        continue;
  911.                                     }
  912.                                     continue loop5;
  913.                                  }
  914.                                  set("\x01",eval("\x01") + 193);
  915.                                  break loop0;
  916.                               }
  917.                            }
  918.                         }
  919.                         set("\x01",eval("\x01") - 365);
  920.                         break;
  921.                      }
  922.                      if(eval("\x01") != 261)
  923.                      {
  924.                         if(eval("\x01") == 74)
  925.                         {
  926.                            set("\x01",eval("\x01") + 848);
  927.                            play();
  928.                            break;
  929.                         }
  930.                         if(eval("\x01") == 922)
  931.                         {
  932.                            set("\x01",eval("\x01") - 922);
  933.                            break;
  934.                         }
  935.                         break;
  936.                      }
  937.                      set("\x01",eval("\x01") - 187);
  938.                      while(true)
  939.                      {
  940.                         if(┬º┬ºpop())
  941.                         {
  942.                            set("\x01",eval("\x01") + 288);
  943.                            break loop0;
  944.                         }
  945.                         if(eval("\x01") == 117)
  946.                         {
  947.                            set("\x01",eval("\x01") + 439);
  948.                            if(┬º┬ºpop())
  949.                            {
  950.                               set("\x01",eval("\x01") + 116);
  951.                            }
  952.                         }
  953.                         else
  954.                         {
  955.                            if(eval("\x01") == 227)
  956.                            {
  957.                               set("\x01",eval("\x01") + 377);
  958.                               break loop0;
  959.                            }
  960.                            if(eval("\x01") == 91)
  961.                            {
  962.                               set("\x01",eval("\x01") + 136);
  963.                               if(┬º┬ºpop())
  964.                               {
  965.                                  set("\x01",eval("\x01") + 377);
  966.                               }
  967.                            }
  968.                            else
  969.                            {
  970.                               if(eval("\x01") == 776)
  971.                               {
  972.                                  set("\x01",eval("\x01") - 597);
  973.                                  break loop0;
  974.                               }
  975.                               if(eval("\x01") == 93)
  976.                               {
  977.                                  set("\x01",eval("\x01") - 93);
  978.                                  break loop0;
  979.                               }
  980.                               if(eval("\x01") == 626)
  981.                               {
  982.                                  set("\x01",eval("\x01") + 171);
  983.                                  if(┬º┬ºpop())
  984.                                  {
  985.                                     set("\x01",eval("\x01") + 66);
  986.                                  }
  987.                               }
  988.                               else
  989.                               {
  990.                                  if(eval("\x01") != 797)
  991.                                  {
  992.                                     break loop0;
  993.                                  }
  994.                                  set("\x01",eval("\x01") + 66);
  995.                                  set(┬º┬ºpop(),┬º┬ºpop() + 411);
  996.                                  throw ┬º┬ºpop()(┬º┬ºpop() lt new ┬º┬ºpop()[┬º┬ºpop()]());
  997.                               }
  998.                            }
  999.                         }
  1000.                         while(true)
  1001.                         {
  1002.                            if(eval("\x01") == 100)
  1003.                            {
  1004.                               set("\x01",eval("\x01") + 526);
  1005.                               ┬º┬ºpush(true);
  1006.                               continue;
  1007.                            }
  1008.                            if(eval("\x01") == 893)
  1009.                            {
  1010.                               set("\x01",eval("\x01") - 193);
  1011.                               if(┬º┬ºpop())
  1012.                               {
  1013.                                  set("\x01",eval("\x01") + 288);
  1014.                               }
  1015.                               continue;
  1016.                            }
  1017.                            if(eval("\x01") == 672)
  1018.                            {
  1019.                               set("\x01",eval("\x01") + 221);
  1020.                               ┬º┬ºpush(true);
  1021.                               continue;
  1022.                            }
  1023.                            if(eval("\x01") == 562)
  1024.                            {
  1025.                               set("\x01",eval("\x01") + 214);
  1026.                               if(┬º┬ºpop())
  1027.                               {
  1028.                                  set("\x01",eval("\x01") - 597);
  1029.                               }
  1030.                               continue;
  1031.                            }
  1032.                            if(eval("\x01") == 988)
  1033.                            {
  1034.                               set("\x01",eval("\x01") - 426);
  1035.                               ┬º┬ºpush(true);
  1036.                               continue;
  1037.                            }
  1038.                            if(eval("\x01") != 179)
  1039.                            {
  1040.                               if(eval("\x01") == 863)
  1041.                               {
  1042.                                  set("\x01",eval("\x01") - 772);
  1043.                                  ┬º┬ºpush(true);
  1044.                               }
  1045.                               else
  1046.                               {
  1047.                                  if(eval("\x01") == 556)
  1048.                                  {
  1049.                                     set("\x01",eval("\x01") + 116);
  1050.                                     break loop0;
  1051.                                  }
  1052.                                  if(eval("\x01") == 357)
  1053.                                  {
  1054.                                     set("\x01",eval("\x01") + 126);
  1055.                                     break loop0;
  1056.                                  }
  1057.                                  if(eval("\x01") == 844)
  1058.                                  {
  1059.                                     set("\x01",eval("\x01") - 487);
  1060.                                     if(┬º┬ºpop())
  1061.                                     {
  1062.                                        set("\x01",eval("\x01") + 126);
  1063.                                     }
  1064.                                  }
  1065.                                  else if(eval("\x01") == 604)
  1066.                                  {
  1067.                                     set("\x01",eval("\x01") + 240);
  1068.                                     ┬º┬ºpush(true);
  1069.                                  }
  1070.                                  else
  1071.                                  {
  1072.                                     if(eval("\x01") != 483)
  1073.                                     {
  1074.                                        break;
  1075.                                     }
  1076.                                     set("\x01",eval("\x01") - 366);
  1077.                                     ┬º┬ºpush(true);
  1078.                                  }
  1079.                               }
  1080.                               continue;
  1081.                            }
  1082.                            set("\x01",eval("\x01") - 86);
  1083.                         }
  1084.                      }
  1085.                   }
  1086.                   stop();
  1087.                }
  1088.                set("\x01",eval("\x01") + 210);
  1089.                ┬º┬ºpush(true);
  1090.             }
  1091.             set("\x01",eval("\x01") + 458);
  1092.             if(┬º┬ºpop())
  1093.             {
  1094.                set("\x01",eval("\x01") - 47);
  1095.             }
  1096.          }
  1097.          set("\x01",eval("\x01") - 642);
  1098.       }
  1099.       set("\x01",eval("\x01") - 55);
  1100.       ┬º┬ºpush(true);
  1101.       continue;
  1102.    }
  1103.    set("\x01",eval("\x01") + 555);
  1104.    ┬º┬ºpush(true);
  1105.    continue;
  1106.    ┬º┬ºpush(true);
  1107. }
  1108.